package com.lb.ai.common.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.FileSystemResource;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Component;
import org.thymeleaf.TemplateEngine;
import org.thymeleaf.context.Context;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import java.io.File;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 邮件发送工具类
 * 支持多种邮件发送方式：
 * 1. 简单文本邮件
 * 2. HTML格式邮件
 * 3. 带附件的邮件（支持自定义附件名）
 * 4. 使用模板的邮件
 * 5. 带图片的邮件
 * 6. 批量发送邮件（支持多种格式）
 *
 * @author LiuB
 * @version 1.0
 */
@Slf4j
@Component
public class EmailUtils {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired(required = false)
    private TemplateEngine templateEngine;

    /**
     * 发送简单文本邮件
     *
     * @param to      收件人邮箱
     * @param subject 邮件主题
     * @param content 邮件内容
     * @return 发送结果
     */
    public boolean sendSimpleEmail(String to, String subject, String content) {
        try {
            SimpleMailMessage message = new SimpleMailMessage();
            message.setTo(to);
            message.setSubject(subject);
            message.setText(content);
            message.setSentDate(new Date());
            mailSender.send(message);
            log.info("简单邮件发送成功，接收者：{}", to);
            return true;
        } catch (Exception e) {
            log.error("简单邮件发送失败，接收者：{}，异常：{}", to, e.getMessage());
            return false;
        }
    }

    /**
     * 发送HTML格式的邮件
     *
     * @param to      收件人邮箱
     * @param subject 邮件主题
     * @param content HTML内容
     * @return 发送结果
     */
    public boolean sendHtmlEmail(String to, String subject, String content) {
        try {
            MimeMessage message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(content, true);
            mailSender.send(message);
            log.info("HTML邮件发送成功，接收者：{}", to);
            return true;
        } catch (MessagingException e) {
            log.error("HTML邮件发送失败，接收者：{}，异常：{}", to, e.getMessage());
            return false;
        }
    }

    /**
     * 发送带附件的邮件（使用原始文件名）
     *
     * @param to       收件人邮箱
     * @param subject  邮件主题
     * @param content  邮件内容
     * @param fileList 附件列表
     * @return 发送结果
     */
    public boolean sendAttachmentsEmail(String to, String subject, String content, List<File> fileList) {
        Map<File, String> fileMap = new HashMap<>();
        for (File file : fileList) {
            fileMap.put(file, file.getName());
        }
        return sendAttachmentsEmail(to, subject, content, fileMap);
    }

    /**
     * 发送带附件的邮件（支持自定义附件名）
     *
     * @param to      收件人邮箱
     * @param subject 邮件主题
     * @param content 邮件内容
     * @param fileMap 附件Map，key为文件对象，value为自定义的附件名
     * @return 发送结果
     */
    public boolean sendAttachmentsEmail(String to, String subject, String content, Map<File, String> fileMap) {
        try {
            MimeMessage message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(content);

            // 添加附件
            for (Map.Entry<File, String> entry : fileMap.entrySet()) {
                File file = entry.getKey();
                String fileName = entry.getValue();
                if (fileName == null || fileName.trim().isEmpty()) {
                    fileName = file.getName();
                }
                FileSystemResource resource = new FileSystemResource(file);
                helper.addAttachment(fileName, resource);
            }

            mailSender.send(message);
            log.info("带附件邮件发送成功，接收者：{}，附件数量：{}", to, fileMap.size());
            return true;
        } catch (MessagingException e) {
            log.error("带附件邮件发送失败，接收者：{}，异常：{}", to, e.getMessage());
            return false;
        }
    }

    /**
     * 发送带图片的邮件
     * 图片将在正文中显示，而不是作为附件
     *
     * @param to       收件人邮箱
     * @param subject  邮件主题
     * @param content  邮件内容（需要包含 <img src="cid:imageId" /> 标签）
     * @param imageMap 图片Map，key为图片ID（对应content中的imageId），value为图片文件
     * @return 发送结果
     */
    public boolean sendInlineImageEmail(String to, String subject, String content, Map<String, File> imageMap) {
        try {
            MimeMessage message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(content, true);

            // 添加图片
            for (Map.Entry<String, File> entry : imageMap.entrySet()) {
                FileSystemResource resource = new FileSystemResource(entry.getValue());
                helper.addInline(entry.getKey(), resource);
            }

            mailSender.send(message);
            log.info("带图片邮件发送成功，接收者：{}，图片数量：{}", to, imageMap.size());
            return true;
        } catch (MessagingException e) {
            log.error("带图片邮件发送失败，接收者：{}，异常：{}", to, e.getMessage());
            return false;
        }
    }

    /**
     * 使用模板发送邮件
     * 需要配置Thymeleaf模板引擎
     *
     * @param to           收件人邮箱
     * @param subject      邮件主题
     * @param templateName 模板名称
     * @param variables    模板变量
     * @return 发送结果
     */
    public boolean sendTemplateEmail(String to, String subject, String templateName, Map<String, Object> variables) {
        if (templateEngine == null) {
            log.error("模板邮件发送失败：未配置Thymeleaf模板引擎");
            return false;
        }

        try {
            MimeMessage message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setTo(to);
            helper.setSubject(subject);

            // 处理模板
            Context context = new Context();
            context.setVariables(variables);
            String content = templateEngine.process(templateName, context);
            helper.setText(content, true);

            mailSender.send(message);
            log.info("模板邮件发送成功，接收者：{}，模板：{}", to, templateName);
            return true;
        } catch (MessagingException e) {
            log.error("模板邮件发送失败，接收者：{}，模板：{}，异常：{}", to, templateName, e.getMessage());
            return false;
        }
    }

    /**
     * 批量发送简单邮件
     *
     * @param toList  收件人列表
     * @param subject 邮件主题
     * @param content 邮件内容
     * @return 发送成功的数量
     */
    public int sendBatchEmail(List<String> toList, String subject, String content) {
        int successCount = 0;
        for (String to : toList) {
            if (sendSimpleEmail(to, subject, content)) {
                successCount++;
            }
        }
        log.info("批量邮件发送完成，总数：{}，成功：{}", toList.size(), successCount);
        return successCount;
    }

    /**
     * 批量发送简单文本邮件
     *
     * @param toList  收件人列表
     * @param subject 邮件主题
     * @param content 邮件内容
     * @return 发送成功的数量
     */
    public int sendBatchSimpleEmail(List<String> toList, String subject, String content) {
        int successCount = 0;
        for (String to : toList) {
            if (sendSimpleEmail(to, subject, content)) {
                successCount++;
            }
        }
        log.info("批量简单邮件发送完成，总数：{}，成功：{}", toList.size(), successCount);
        return successCount;
    }

    /**
     * 批量发送HTML格式邮件
     *
     * @param toList  收件人列表
     * @param subject 邮件主题
     * @param content HTML内容
     * @return 发送成功的数量
     */
    public int sendBatchHtmlEmail(List<String> toList, String subject, String content) {
        int successCount = 0;
        for (String to : toList) {
            if (sendHtmlEmail(to, subject, content)) {
                successCount++;
            }
        }
        log.info("批量HTML邮件发送完成，总数：{}，成功：{}", toList.size(), successCount);
        return successCount;
    }

    /**
     * 批量发送带附件的邮件
     *
     * @param toList  收件人列表
     * @param subject 邮件主题
     * @param content 邮件内容
     * @param fileMap 附件Map，key为文件对象，value为自定义的附件名
     * @return 发送成功的数量
     */
    public int sendBatchAttachmentsEmail(List<String> toList, String subject, String content, Map<File, String> fileMap) {
        int successCount = 0;
        for (String to : toList) {
            if (sendAttachmentsEmail(to, subject, content, fileMap)) {
                successCount++;
            }
        }
        log.info("批量附件邮件发送完成，总数：{}，成功：{}，附件数：{}", toList.size(), successCount, fileMap.size());
        return successCount;
    }

    /**
     * 批量发送带图片的邮件
     *
     * @param toList   收件人列表
     * @param subject  邮件主题
     * @param content  邮件内容（需要包含 <img src="cid:imageId" /> 标签）
     * @param imageMap 图片Map，key为图片ID（对应content中的imageId），value为图片文件
     * @return 发送成功的数量
     */
    public int sendBatchInlineImageEmail(List<String> toList, String subject, String content, Map<String, File> imageMap) {
        int successCount = 0;
        for (String to : toList) {
            if (sendInlineImageEmail(to, subject, content, imageMap)) {
                successCount++;
            }
        }
        log.info("批量图片邮件发送完成，总数：{}，成功：{}，图片数：{}", toList.size(), successCount, imageMap.size());
        return successCount;
    }

    /**
     * 批量发送模板邮件
     *
     * @param toList       收件人列表
     * @param subject      邮件主题
     * @param templateName 模板名称
     * @param variables    模板变量
     * @return 发送成功的数量
     */
    public int sendBatchTemplateEmail(List<String> toList, String subject, String templateName, Map<String, Object> variables) {
        int successCount = 0;
        for (String to : toList) {
            if (sendTemplateEmail(to, subject, templateName, variables)) {
                successCount++;
            }
        }
        log.info("批量模板邮件发送完成，总数：{}，成功：{}，模板：{}", toList.size(), successCount, templateName);
        return successCount;
    }

    /**
     * 批量发送带附件的HTML邮件
     *
     * @param toList  收件人列表
     * @param subject 邮件主题
     * @param content HTML内容
     * @param fileMap 附件Map，key为文件对象，value为自定义的附件名
     * @return 发送成功的数量
     */
    public int sendBatchHtmlWithAttachmentsEmail(List<String> toList, String subject, String content, Map<File, String> fileMap) {
        try {
            int successCount = 0;
            for (String to : toList) {
                MimeMessage message = mailSender.createMimeMessage();
                MimeMessageHelper helper = new MimeMessageHelper(message, true);
                helper.setTo(to);
                helper.setSubject(subject);
                helper.setText(content, true);  // 设置为HTML格式

                // 添加附件
                for (Map.Entry<File, String> entry : fileMap.entrySet()) {
                    File file = entry.getKey();
                    String fileName = entry.getValue();
                    if (fileName == null || fileName.trim().isEmpty()) {
                        fileName = file.getName();
                    }
                    FileSystemResource resource = new FileSystemResource(file);
                    helper.addAttachment(fileName, resource);
                }

                mailSender.send(message);
                successCount++;
            }
            log.info("批量HTML附件邮件发送完成，总数：{}，成功：{}，附件数：{}", toList.size(), successCount, fileMap.size());
            return successCount;
        } catch (MessagingException e) {
            log.error("批量HTML附件邮件发送失败，异常：{}", e.getMessage());
            return 0;
        }
    }

    /**
     * 批量发送带图片和附件的HTML邮件
     *
     * @param toList   收件人列表
     * @param subject  邮件主题
     * @param content  HTML内容（需要包含 <img src="cid:imageId" /> 标签）
     * @param imageMap 图片Map，key为图片ID，value为图片文件
     * @param fileMap  附件Map，key为文件对象，value为自定义的附件名
     * @return 发送成功的数量
     */
    public int sendBatchComplexEmail(List<String> toList, String subject, String content,
                                     Map<String, File> imageMap, Map<File, String> fileMap) {
        try {
            int successCount = 0;
            for (String to : toList) {
                MimeMessage message = mailSender.createMimeMessage();
                MimeMessageHelper helper = new MimeMessageHelper(message, true);
                helper.setTo(to);
                helper.setSubject(subject);
                helper.setText(content, true);

                // 添加图片
                for (Map.Entry<String, File> entry : imageMap.entrySet()) {
                    FileSystemResource resource = new FileSystemResource(entry.getValue());
                    helper.addInline(entry.getKey(), resource);
                }

                // 添加附件
                for (Map.Entry<File, String> entry : fileMap.entrySet()) {
                    File file = entry.getKey();
                    String fileName = entry.getValue();
                    if (fileName == null || fileName.trim().isEmpty()) {
                        fileName = file.getName();
                    }
                    FileSystemResource resource = new FileSystemResource(file);
                    helper.addAttachment(fileName, resource);
                }

                mailSender.send(message);
                successCount++;
            }
            log.info("批量复杂邮件发送完成，总数：{}，成功：{}，图片数：{}，附件数：{}",
                    toList.size(), successCount, imageMap.size(), fileMap.size());
            return successCount;
        } catch (MessagingException e) {
            log.error("批量复杂邮件发送失败，异常：{}", e.getMessage());
            return 0;
        }
    }
} 